/*
 * Copyright (c) 2017-2019 THL A29 Limited, a Tencent company. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef TENCENTCLOUD_CWP_V20180228_MODEL_MODIFYMALWARETIMINGSCANSETTINGSREQUEST_H_
#define TENCENTCLOUD_CWP_V20180228_MODEL_MODIFYMALWARETIMINGSCANSETTINGSREQUEST_H_

#include <string>
#include <vector>
#include <map>
#include <tencentcloud/core/AbstractModel.h>


namespace TencentCloud
{
    namespace Cwp
    {
        namespace V20180228
        {
            namespace Model
            {
                /**
                * ModifyMalwareTimingScanSettings请求参数结构体
                */
                class ModifyMalwareTimingScanSettingsRequest : public AbstractModel
                {
                public:
                    ModifyMalwareTimingScanSettingsRequest();
                    ~ModifyMalwareTimingScanSettingsRequest() = default;
                    std::string ToJsonString() const;


                    /**
                     * 获取检测模式 0 全盘检测  1快速检测
                     * @return CheckPattern 检测模式 0 全盘检测  1快速检测
                     */
                    uint64_t GetCheckPattern() const;

                    /**
                     * 设置检测模式 0 全盘检测  1快速检测
                     * @param CheckPattern 检测模式 0 全盘检测  1快速检测
                     */
                    void SetCheckPattern(const uint64_t& _checkPattern);

                    /**
                     * 判断参数 CheckPattern 是否已赋值
                     * @return CheckPattern 是否已赋值
                     */
                    bool CheckPatternHasBeenSet() const;

                    /**
                     * 获取检测周期 开始时间，如：02:00:00
                     * @return StartTime 检测周期 开始时间，如：02:00:00
                     */
                    std::string GetStartTime() const;

                    /**
                     * 设置检测周期 开始时间，如：02:00:00
                     * @param StartTime 检测周期 开始时间，如：02:00:00
                     */
                    void SetStartTime(const std::string& _startTime);

                    /**
                     * 判断参数 StartTime 是否已赋值
                     * @return StartTime 是否已赋值
                     */
                    bool StartTimeHasBeenSet() const;

                    /**
                     * 获取检测周期 超时结束时间，如：04:00:00
                     * @return EndTime 检测周期 超时结束时间，如：04:00:00
                     */
                    std::string GetEndTime() const;

                    /**
                     * 设置检测周期 超时结束时间，如：04:00:00
                     * @param EndTime 检测周期 超时结束时间，如：04:00:00
                     */
                    void SetEndTime(const std::string& _endTime);

                    /**
                     * 判断参数 EndTime 是否已赋值
                     * @return EndTime 是否已赋值
                     */
                    bool EndTimeHasBeenSet() const;

                    /**
                     * 获取是否全部服务器 1 全部 2 自选
                     * @return IsGlobal 是否全部服务器 1 全部 2 自选
                     */
                    uint64_t GetIsGlobal() const;

                    /**
                     * 设置是否全部服务器 1 全部 2 自选
                     * @param IsGlobal 是否全部服务器 1 全部 2 自选
                     */
                    void SetIsGlobal(const uint64_t& _isGlobal);

                    /**
                     * 判断参数 IsGlobal 是否已赋值
                     * @return IsGlobal 是否已赋值
                     */
                    bool IsGlobalHasBeenSet() const;

                    /**
                     * 获取定时检测开关 0 关闭 1开启
                     * @return EnableScan 定时检测开关 0 关闭 1开启
                     */
                    uint64_t GetEnableScan() const;

                    /**
                     * 设置定时检测开关 0 关闭 1开启
                     * @param EnableScan 定时检测开关 0 关闭 1开启
                     */
                    void SetEnableScan(const uint64_t& _enableScan);

                    /**
                     * 判断参数 EnableScan 是否已赋值
                     * @return EnableScan 是否已赋值
                     */
                    bool EnableScanHasBeenSet() const;

                    /**
                     * 获取监控模式 0 标准 1深度
                     * @return MonitoringPattern 监控模式 0 标准 1深度
                     */
                    uint64_t GetMonitoringPattern() const;

                    /**
                     * 设置监控模式 0 标准 1深度
                     * @param MonitoringPattern 监控模式 0 标准 1深度
                     */
                    void SetMonitoringPattern(const uint64_t& _monitoringPattern);

                    /**
                     * 判断参数 MonitoringPattern 是否已赋值
                     * @return MonitoringPattern 是否已赋值
                     */
                    bool MonitoringPatternHasBeenSet() const;

                    /**
                     * 获取扫描周期 默认每天 1
                     * @return Cycle 扫描周期 默认每天 1
                     */
                    uint64_t GetCycle() const;

                    /**
                     * 设置扫描周期 默认每天 1
                     * @param Cycle 扫描周期 默认每天 1
                     */
                    void SetCycle(const uint64_t& _cycle);

                    /**
                     * 判断参数 Cycle 是否已赋值
                     * @return Cycle 是否已赋值
                     */
                    bool CycleHasBeenSet() const;

                    /**
                     * 获取实时监控 0 关闭 1开启
                     * @return RealTimeMonitoring 实时监控 0 关闭 1开启
                     */
                    uint64_t GetRealTimeMonitoring() const;

                    /**
                     * 设置实时监控 0 关闭 1开启
                     * @param RealTimeMonitoring 实时监控 0 关闭 1开启
                     */
                    void SetRealTimeMonitoring(const uint64_t& _realTimeMonitoring);

                    /**
                     * 判断参数 RealTimeMonitoring 是否已赋值
                     * @return RealTimeMonitoring 是否已赋值
                     */
                    bool RealTimeMonitoringHasBeenSet() const;

                    /**
                     * 获取自选服务器时必须 主机quuid的string数组
                     * @return QuuidList 自选服务器时必须 主机quuid的string数组
                     */
                    std::vector<std::string> GetQuuidList() const;

                    /**
                     * 设置自选服务器时必须 主机quuid的string数组
                     * @param QuuidList 自选服务器时必须 主机quuid的string数组
                     */
                    void SetQuuidList(const std::vector<std::string>& _quuidList);

                    /**
                     * 判断参数 QuuidList 是否已赋值
                     * @return QuuidList 是否已赋值
                     */
                    bool QuuidListHasBeenSet() const;

                private:

                    /**
                     * 检测模式 0 全盘检测  1快速检测
                     */
                    uint64_t m_checkPattern;
                    bool m_checkPatternHasBeenSet;

                    /**
                     * 检测周期 开始时间，如：02:00:00
                     */
                    std::string m_startTime;
                    bool m_startTimeHasBeenSet;

                    /**
                     * 检测周期 超时结束时间，如：04:00:00
                     */
                    std::string m_endTime;
                    bool m_endTimeHasBeenSet;

                    /**
                     * 是否全部服务器 1 全部 2 自选
                     */
                    uint64_t m_isGlobal;
                    bool m_isGlobalHasBeenSet;

                    /**
                     * 定时检测开关 0 关闭 1开启
                     */
                    uint64_t m_enableScan;
                    bool m_enableScanHasBeenSet;

                    /**
                     * 监控模式 0 标准 1深度
                     */
                    uint64_t m_monitoringPattern;
                    bool m_monitoringPatternHasBeenSet;

                    /**
                     * 扫描周期 默认每天 1
                     */
                    uint64_t m_cycle;
                    bool m_cycleHasBeenSet;

                    /**
                     * 实时监控 0 关闭 1开启
                     */
                    uint64_t m_realTimeMonitoring;
                    bool m_realTimeMonitoringHasBeenSet;

                    /**
                     * 自选服务器时必须 主机quuid的string数组
                     */
                    std::vector<std::string> m_quuidList;
                    bool m_quuidListHasBeenSet;

                };
            }
        }
    }
}

#endif // !TENCENTCLOUD_CWP_V20180228_MODEL_MODIFYMALWARETIMINGSCANSETTINGSREQUEST_H_
